home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C++ / Libraries / Two Way Notes / two_way_list.cp < prev    next >
Encoding:
Text File  |  1994-04-24  |  6.4 KB  |  321 lines  |  [TEXT/KAHL]
  1. /********************************************************/
  2. /*                                                      */
  3. /*                 Two_Way_List.cp                      */
  4. /*                 Routines for: Two_Way_List           */
  5. /*                 Copyright 4/24/94 Hasan Edain        */
  6. /*                 All Reights Reserved Worldwide       */
  7. /*                                                      */
  8. /********************************************************/
  9.  
  10. //    Please feel free to modify and use this code for any purpose, as long as you
  11. // send me
  12. // a) source of the modified code.
  13. // b) licenced version of product the code is used in.
  14. // c) notes as to how the code could be made more usefull if you tried to use it, but
  15. // ended up not using it for any reason.
  16. // Hasan Edain
  17. // HasanEdain@AOL.com
  18. // box 667 Langley Wa 98260
  19. // fax: 206-579-6456
  20.  
  21. #include <stdlib.h>
  22.  
  23. #include "two_way.h"
  24.  
  25. #include "monster.h"
  26.  
  27. /*************************list::initList*********************************/
  28. list *list::initList(void *data, unsigned long dataLength, short dataKey)
  29. {
  30. node *newNode;
  31. list *newList;
  32.  
  33. newList = new list;
  34. newNode = new node;
  35.  
  36. if(newList && newNode)
  37.     {
  38.     newNode->fillNode(newNode, newNode,data,dataLength, dataKey);
  39.     newList->first = newNode;
  40.     newList->last = newNode;
  41.     newList->curr = newNode;
  42.     newList->nodeCount = 1;
  43.     return(newList);
  44.     }
  45. else
  46.     {
  47.     return(NULL);
  48.     }
  49. }
  50.  
  51. /*************************list::addFirstNode*********************************/
  52. short list::addFirstNode(void *data, unsigned long dataLength, short dataKey)
  53. {
  54. node *newNode;
  55.  
  56. newNode = new node;
  57. if(newNode)
  58.     {
  59.     newNode->fillNode(newNode, first,data,dataLength,dataKey);
  60.     first->setPrevNode(newNode);
  61.     first = newNode;
  62.     curr = newNode;
  63.     nodeCount++;
  64.     return(1);
  65.     }
  66. else
  67.     {
  68.     return(0);
  69.     }
  70. }
  71.  
  72. /*************************list::addNodeBeforeCurrent*********************************/
  73. short list::addNodeBeforeCurrent(void *data, unsigned long dataLength, short dataKey)
  74. {
  75. node    *newNode;
  76. short    error;
  77. if(first != curr)
  78.     {
  79.     newNode = new node;
  80.     if(newNode)
  81.         {
  82.         newNode->fillNode(curr->getPrevNode(), curr,data,dataLength,dataKey);
  83.         ( (curr->getPrevNode()) ->setNextNode(newNode));
  84.         curr->setPrevNode(newNode);
  85.         curr = newNode;
  86.         nodeCount++;
  87.         return(1);
  88.         }
  89.     else
  90.         {
  91.         return(0);
  92.         }
  93.     }
  94. else
  95.     {
  96.     error = this->addFirstNode(data,dataLength,dataKey);
  97.     if(error)
  98.         {
  99.         return(1);
  100.         }
  101.     else
  102.         {
  103.         return(0);
  104.         }
  105.     }
  106. }
  107.  
  108. /*************************list::addNodeAfterCurrent*********************************/
  109. short list::addNodeAfterCurrent(void *data, unsigned long dataLength, short dataKey)
  110. {
  111. node    *newNode;
  112. short    error;
  113. if(last != curr)
  114.     {
  115.     newNode = new node;
  116.     if(newNode)
  117.         {
  118.         newNode->fillNode(curr, curr->getNextNode(),data,dataLength,dataKey);
  119.         ( (curr->getNextNode()) ->setPrevNode(newNode));
  120.         curr->setNextNode(newNode);
  121.         curr = newNode;
  122.         nodeCount++;
  123.         return(1);
  124.         }
  125.     else
  126.         {
  127.         return(0);
  128.         }
  129.     }
  130. else
  131.     {
  132.     error = this->addLastNode(data,dataLength,dataKey);
  133.     if(error)
  134.         {
  135.         return(1);
  136.         }
  137.     else
  138.         {
  139.         return(0);
  140.         }
  141.     }
  142. }
  143.  
  144. /*************************list::addLastNode*********************************/
  145. short list::addLastNode(void *data, unsigned long dataLength, short dataKey)
  146. {
  147. node *newNode;
  148.  
  149. newNode = new node;
  150.  
  151. if(newNode)
  152.     {
  153.     newNode->fillNode(last, newNode,data,dataLength,dataKey);
  154.     last->setNextNode(newNode);
  155.     last = newNode;
  156.     curr = newNode;
  157.     nodeCount++;
  158.     return(1);
  159.     }
  160. else
  161.     {
  162.     return(0);
  163.     }
  164. }
  165.  
  166. /*************************list::extractFirstNode*********************************/
  167. void *list::extractFirstNode(short *dataKey, unsigned long *dataLength)
  168. {
  169. *dataKey = first->getDataKey();
  170. *dataLength = first->getDataLength();
  171. return(first->getData());
  172. }
  173.  
  174. /*************************list::extractCurrNode*********************************/
  175. void *list::extractCurrNode(short *dataKey, unsigned long *dataLength)
  176. {
  177. *dataKey = curr->getDataKey();
  178. *dataLength = curr->getDataLength();
  179. return(curr->getData());
  180. }
  181.  
  182. /*************************list::extractNthNode*********************************/
  183. void *list::extractNthNode(short *dataKey, unsigned long *dataLength, short n)
  184. {
  185. short length, halfLength;
  186. short i;
  187.  
  188. length = this->getListLength();
  189. halfLength = length/2;
  190. if(n<=length)
  191.     {
  192.     if(n <= halfLength)
  193.         {
  194.         this->moveCurrNodeToStart();
  195.         for(i=1; i<n; i++)
  196.             {
  197.             this->moveCurrNodeForward();
  198.             }
  199.         }
  200.     else
  201.         {
  202.         this->moveCurrNodeToEnd();
  203.         for(i=length; i>n; i--)
  204.             {
  205.             this->moveCurrNodeBackward();
  206.             }
  207.         }
  208.     }
  209. *dataKey = curr->getDataKey();
  210. *dataLength = curr->getDataLength();
  211. return(curr->getData());
  212. }
  213.  
  214. /*************************list::extractLastNode*********************************/
  215. void *list::extractLastNode(short *dataKey, unsigned long *dataLength)
  216. {
  217. *dataKey = last->getDataKey();
  218. *dataLength = last->getDataLength();
  219. return(last->getData());
  220. }
  221.  
  222. /*************************list::moveCurrNodeForward*********************************/
  223. void    list::moveCurrNodeForward(void)
  224. {
  225. if(curr != last)
  226.     {
  227.     curr = curr->getNextNode();
  228.     }
  229. }
  230.  
  231. /*************************list::moveCurrNodeToStart*********************************/
  232. void    list::moveCurrNodeToStart(void)
  233. {
  234. curr = first;
  235. }
  236.  
  237. /*************************list::moveCurrNodeToNth*********************************/
  238. void    list::moveCurrNodeToNth(short n)
  239. {
  240. short length, halfLength;
  241. short i;
  242.  
  243. length = this->getListLength();
  244. halfLength = length/2;
  245.  
  246. if(n<=length)
  247.     {
  248.     if(n<=halfLength)
  249.         {
  250.         this->moveCurrNodeToStart();
  251.         for(i=1;i<n;i++)
  252.             {
  253.             this->moveCurrNodeForward();
  254.             }
  255.         }
  256.     else
  257.         {
  258.         this->moveCurrNodeToEnd();
  259.         for(i=length;i>n;i--)
  260.             {
  261.             this->moveCurrNodeBackward();
  262.             }
  263.         }
  264.     }
  265. curr = last;
  266. }
  267.  
  268. /*************************list::moveCurrNodeToEnd*********************************/
  269. void    list::moveCurrNodeToEnd(void)
  270. {
  271. curr = last;
  272. }
  273.  
  274. /*************************list::moveCurrNodeBackward*********************************/
  275. void    list::moveCurrNodeBackward(void)
  276. {
  277. if(curr != first)
  278.     {
  279.     curr = curr->getPrevNode();
  280.     }
  281. }
  282.  
  283. /*************************list::deleteFirstNode*********************************/
  284. void list::deleteFirstNode(void)
  285. {
  286. node  *temp;
  287.  
  288. if(nodeCount > 1)
  289.     {
  290.     temp = first;
  291.     if(curr == first)
  292.         {
  293.         curr = first->getNextNode();
  294.         }
  295.     first = first->getNextNode();
  296.     nodeCount--;
  297.     temp->deleteNode();
  298.     }
  299. else
  300.     {
  301.     this->deleteList();
  302.     }
  303. }
  304.  
  305. /*************************list::deleteList*********************************/
  306. void list::deleteList(void)
  307. {
  308. short i;
  309.  
  310. for(i=1; i<nodeCount; i++)
  311.     {
  312.     first->deleteNode();
  313.     }
  314. delete this;
  315. }
  316.  
  317. /*************************list::getListLength*********************************/
  318. short    list::getListLength(void)
  319. {
  320. return(nodeCount);
  321. }